ADA Programming Guide/ADA Programming Guide.iso/ada_faqs/cld9z141.txt

Text File | 1996-01-30 | 74KB | 1,620 lines

Archive-name: comp-lang-ada/cla-faq1


comp.lang.ada Frequently Asked Questions (FAQ) part 1 of 2

Effective date: 4 JUN 93

Currently, the comp.lang.ada FAQ is maintained by the Ada Information
Clearinghouse ([e-mail]).  It is available for
downloading via anonymous FTP from the AJPO host (ajpo.sei.cmu.edu)
from the public/comp-lang-ada subdirectory as files cla-faq1 and
cla-faq2.

Frequency: This will be posted every other month to comp.lang.ada,
news.answers, and comp.answers.

Changes since the last FAQ: Three on the Ada Semantic Interface
Specification (ASIS); otherwise, no changes since last time.

Individuals are encouraged to submit both questions and answers.  In
many answers below, submitters are noted in parentheses at the
beginning of comments.  (Comments may be slightly edited.)

It should be noted that report of a product, service, or event, etc.,
does not constitute an endorsement by the AdaIC or the Ada Joint
Program Office.  Opinions expressed are those of the submitters.

Table of Contents:

   1) Where can I get a list of validated Ada compilers?
   2) Where can I get a yacc/ayacc grammar to read Ada code?
   3) Is there an Ada-mode for Emacs?
   4) You know, I think Ada could really benefit from having
      <choose_a_feature> from <choose_a_language>...
   5) I just saw a very anti-Ada post that I think is definitely
      wrong.  Why didn't anybody post a response to it?  Should I?
   6) Where can I get a public-domain Ada compiler?
   7) Is Ada a registered trademark of the US government?
   8) I have seen the language name capitalized as ADA, as well as
      Ada.  Which is right?
   9) What is Ada 9X?
  10) What is Anna, and where can I get it?
  11) What is DRAGOON, and where can I get it?
  12) Does anyone have a list of commercial Ada projects?
  13) Are there versions of lex and yacc that generate Ada code?
  14) What ftp sites exist that contain information about Ada or Ada
      source?
  15) What organizations exist that deal with Ada and Ada issues?
      (Long)
  16) What cheap (<500$) Ada compilers are available?
  17) Are there any dialup BBS systems that deal with Ada?
  18) Does anyone know where I can get bindings for Ada?  X-Windows?
      Others?  (See 22 and 23 for specific reference to POSIX.)
  19) Is there a list of Ada compiler vendor e-mail contacts?
  20) Is there a list of good Ada books?  (Long)
  21) Where can I get language translators?  And should I?
  22) What is the status of the POSIX/Ada work?
  23) How can I get a copy of POSIX/Ada?  Is it available via FTP?
  24) Where can I get Ada benchmark programs?
  25) The AJPO host has a lot of Ada information files available for
      downloading by anonymous FTP.  But I don't have FTP service on
      the Internet host where I have an account.  Is there any way I
      can get those files?
  26) What is ASIS?
  27) How can I find out more about ASIS?  Can I take part in
      development?
  28) How can I get hold of ASIS?


 1) Where can I get a list of validated Ada compilers?

      (from [e-mail])

      By anonymous ftp from ajpo.sei.cmu.edu.  The latest list is in
      the /public/ada-info directory.  Only the latest list is kept;
      it has the name val-comp.hlp.ddmmmyy, where dd stands for date,
      mmm for month (3-letter abreviation), and yy stands for year.
      For example, the current list is val-comp.hlp.01Oct92.  If the
      list is updated during the month, the previous one is deleted
      and the date part of the name of the file will change.

 2) Where can I get a yacc/ayacc grammar to read Ada code?

      (from [e-mail] (Gary Morris @lone))

      [e-mail] has kindly sent in a yacc and lex
      grammar for Ada.  It's available via FTP from the archives at
      primost.cs.wisc.edu and via e-mail from the compilers server at
      [e-mail].

 3) Is there an Ada-mode for Emacs?

      (from [e-mail] (Heddy Boubaker))

      There are, in fact, 3 ada modes for emacs

      - There is a simple ada-mode shipped as part of the emacs
        distribution.

      - a more elaborate one from Steven D. Litvintchouk of Mitre
        Corp called electric-ada

      - and gnu-ada mode.  Here is a small description of the features
        of this mode:

          1/ Compile programs within emacs
          Run compiler as inferior of Emacs, and parse its error
          messages.  NOTE: I believe that this feature will only work
          with VADS, but it might have been tailored to work with
          other compilers.

          2/ Ada dired
          It supplies a form of dired that helps manage the VADS
          environment, and it adds ADA vads commands into ada mode.
          Unlike a previous dired-ada implementation, this version
          uses the existing dired mode functions except where there is
          unresolvable conflict.  Thus, this is more like a minor mode
          to dired.  Very important because on actual version of emacs
          19(beta), in fact lemacs (lucid emacs), dired has changed
          and we can no longer use gnu-ada mode :-(

          3/ you can consult Ada LRM(*) during parsing error message.
          (*)You can get one in wsmr-simtel20.army.mil or any
          mirror site.

          4/ smart indentation
          Tries hard to do all the indenting automatically.
          Emphasizes correct insertion of new code using smart
          templates.

          5/ Smart template commands (bnf)
          This is essentially a bnf processor/language-sensitive
          editor.  The next message will give you an ada bnf file that
          you can use within ada-mode to expand nonterminals.  But you
          can roll your own grammars (e.g., your design grammar or an
          ADL) and put them in *.bnf files ..
          ; The BNF rule set is stored as a list of rules.

          6/ debugging Ada programs within emacs
          A facility is provided for the simultaneous display of the
          source code in one window, while using a.db to step through
          a function in the other.  A small arrow "=>" in the source
          window, indicates the current line.

          7/ Move from procedure to procedure or package to package
          ...

          8/ tags Ada

          9/ and other things ...

      (from [e-mail] (Pascal OBRY))

      You can find the gnu-ada mode in
      ajpo.sei.cmu.edu
      cd /public/infoada/gnu
      file r1.06a-ada.tar.Z

 4) You know, I think Ada could really benefit from having
      <choose_a_feature> from <choose_a_language>
    or
    You know, I think Ada is clearly <inferior_or_superior> to
      <choose_a_language> because it has <choose_a_feature>

      (from [e-mail] (Drew Johnson))

      Such posts almost always result in religious wars about langauge
      and produce only wasted bandwidth.  PLEASE refrain from such
      posts unless you have a specific question about Ada.  For
      example, the following kind of question *is* appropriate: "In
      <choose_a_language> I can do <choose_a_feature>.  How would I go
      about doing this in Ada?"

 5) I just saw a very anti-Ada post that I think is definitely wrong.  Why
    didn't anybody post a response to it?  Should I?

      (from [e-mail] (Drew Johnson))

      Ada apparently gets more than its share of attacks, probably due
      to its unique origins, and the fact that it is a requirement for
      some government software.  For the same reasons as in (4) above,
      PLEASE refrain from posting a response to these, unless you feel
      there is something of *significant* importance that you can
      contribute.  Posts containing factual corrections are probably
      OK, but posts like "Well, I've used Ada on many projects, and
      all have been very successful" accomplish nothing.  If you are
      really dead-set on driving your point home to the poster, you
      can do it via e-mail.

 6) Where can I get a public-domain Ada compiler?

      There is currently no public-domain Ada compiler available.
      However, a compiler for Ada 9X is in the works, and there is an
      interpreter for Ada 83.  The interpreter is available from the
      New York University host (cd.nyu.edu, Internet address
      128.122.140.24).

      Interpreter for Ada 83:
      (from [e-mail] (Michael Feldman))

      While there is no PD 'compiler', Ada/Ed is available, which is
      an Ada interpreter.  It is available for PCs, Unix-based
      machines, Amiga, and Atari systems.  Excerpt from the Ada/Ed
      README:

      Ada/Ed is a translator-interpreter for Ada.  It is intended as a
      teaching tool, and does not have the capacity, performance, or
      robustness of commercial Ada compilers.  Ada/Ed was developed at
      New York University, as part of a long-range project in language
      definition and software prototyping.  The project produced the
      first validated translator for Ada, in the form of an executable
      definition of the language written in SETL.  The SETL system
      served as design document and prototype for the C version
      [available from the NYU host.]

      Ada/Ed was last validated under version 1.7 of the ACVC tests.
      Therefore it is not currently a validated Ada system, and users
      can expect to find small discrepancies between Ada/Ed and
      currently validated compilers.

      Apart from the 100-odd tests of ACVC 1.11 that Ada/Ed currently
      fails, the major deficiency of the system is that, being an
      interpreter, it does not implement most representation clauses,
      and thus does not support systems programming close to the
      machine level.

      Compiler for Ada 9X:
      GNU is officially working on a free Ada compiler.

      (from [e-mail] (Ed Schonberg))

      The Computer Science Department of the Courant Institute of
      Mathematical Sciences at New York University is pleased to
      announce that it has received a contract from the Ada/9X Project
      Office to develop a GNU/Ada system.  The work is being
      cosponsored by DARPA and the Ada Joint Project Office, under the
      direction of Christine M. Anderson.

      The project involves the implementation of a highly efficient
      compiler system for the Ada language.  The compiler is to be an
      integral part of the GCC system, distributed by the Free
      Software Foundation.  Richard Stallman, head of the FSF, is
      cooperating closely with NYU to ensure that the new Ada
      component will fit smoothly into GCC.  GNU/Ada will be
      distributed as a standard part of the GCC system.

      The project is under the direction of Professors Robert B. K.
      Dewar and Edmond Schonberg.  The design team includes members of
      the NYUADA project as well as GCC designers.  Bernard Banner,
      Franco Gasperoni, Brett Porter and Gail Schenker have
      participated in various aspects of the design and implementation
      of Ada/Ed.  Richard Kenner has retargetted the GCC backend to
      several modern RISC architectures.  Sam Figueroa, Laurent Bardet
      and several graduate students will participate in the design and
      implementation of selected modules of the run-time.  Finally,
      Jean-Pierre Rosen, one of the original designers of Ada/Ed, will
      be acting as a consultant in the area of tasking.  Collectively,
      this group represents over a hundred person-years of experience
      in Ada implementation and compiler technology.

      The project has an opening for one additional senior staff
      person.  Substantial experience in compiler technology is
      required, as well as fluency in Ada.  Those interested should
      send e-mail to [e-mail] or [e-mail].

      The main goal of the project, nicknamed GNAT (GNU NYU Ada
      Translator) is to provide a free implementation of Ada/9X, the
      new version of Ada currently being designed.  As is well-known,
      the name Ada/9X reflects the fact that the completion date for
      its standardization is not yet known, although it is expected
      that X will be 3 or 4.  GNAT will implement as much as possible
      of the Ada/9X design over the 18 month duration of the project;
      it is anticipated that all the important functionality of Ada/9X
      will be covered.  The project does not include any commitment to
      formal validation, since neither the approved standard, nor the
      validation suite will be available in time.  Instead, the
      objective is to provide to the Ada community, in the most timely
      fashion, a reasonably complete implementation distributed with
      full sources under the standard GNU public licence.  The system
      will allow implementors, educators, and software professionals
      to experiment with the new language at the earliest possible
      time.

      Since ANSI Ada/83 is, with very few exceptions, a subset of
      Ada/9X, the GNU/Ada system will be able to process and correctly
      execute Ada/83 programs as well as Ada/9X programs.  Two major
      releases of the system are scheduled, at staged levels of
      functionality: one in June 1993, and the second at the end of
      calendar 1993.

      We are establishing an external mailing list for distribution of
      GNAT documents and design information.  If you would like to be
      on this distribution list, please send e-mail to
      [e-mail].

 7) Is Ada a registered trademark of the US government?

      (from the AdaIC)

      No, but it used to be; there's a "certification mark", though,
      which is to be used only for validated compilers.

      Prior to November 30, 1987, the name "Ada" was a registered
      trademark.  In the December 1987 issue of the Ada Information
      Clearinghouse Newsletter, Ms. Virginia Castor, then Director of
      the Ada Joint Program Office (AJPO), announced that the
      Department of Defense would thereafter rely on a certification
      mark instead of a trademark.

      (The certification mark is a Pentagon-shaped symbol with a
      "Validated Ada" message, and can be seen on the documentation of
      validated Ada compilers.)

      The text of the 1987 AJPO announcement is available as an AdaIC
      file (trademrk.hlp.25Apr91) in the public/ada-info directory on
      the AJPO host (ajpo.sei.cmu.edu).

8) I have seen the language name capitalized as ADA, as well as Ada.  Which
   is right?

      (from [e-mail] (Drew Johnson))

      The correct capitalization is Ada.  It's a proper name, for Ada
      Lovelace (1815-1852), who is regarded to be the world's first
      programmer.

      Using all-caps usually implies an acronym, and we are not
      talking about the American Dental Association :).

9) What is Ada 9X?

      (from [e-mail] (Drew Johnson))

      Ada 9X refers to the revised version of Ada.  (Ada 83 is the
      current ANSI/ISO standard.)  The Ada 9X Project Office is
      responsible for the revision, and is working closely with the
      international community to ensure Ada retains its ISO status.
      The Ada 9X process is very open.  Volunteer Reviewers are
      welcome and should contact [e-mail].  Many
      draft documents are on-line on the Ada 9X bulletin board,
      1-800-Ada9X 25.  For further information contact the Ada 9X
      Project Office, PL/VTET, Kirtland AFB, New Mexico 87117-6008.

      Ada 9X includes three major areas of enhancement: support for
      object-oriented programming, programming-in-the-large, and
      realtime systems.

      A great deal of attention is being focused on transitioning to
      Ada 9X.  The validation test suite will be available early (in
      draft form prior to ANSI/ISO approval with official release 3
      months after ANSI/ISO approval).  However, for a two-year period
      vendors will be able to focus on enhanced areas of the language
      that their customer base wants first; i.e., the first validation
      test suite will be modularly constructed.  Vendors are also being
      encouraged to release beta-versions of their Ada 9X
      implementations prior to validation.

      There will also be a GNU Ada 9X compilation system available in
      late 1993.

10) What is Anna, and where can I get it?

      (from [e-mail] (Drew Johnson))

      Anna is a language for formally specifying Ada programs.  It
      extends Ada with various different kinds of specification
      constructs from ones as simple as assertions, to as complex as
      algebraic specifications.  A whole lot of tools have been
      implemented for Anna, including:

      1.  The standard DIANA extension packages, parsers,
      pretty-printers.

      2.  Semantic checker (very similar to standard semantic checkers
      for programming languages).

      3.  Specification analyzer -- this is a tool used to test a
      specification for correctness before a program based on the
      specification is written.

      4.  Annotation transformer -- this transforms Anna specification
      constructs into checks on the Ada program that is developed
      based on the specification.  This tool is currently in the
      process of being enhanced so that it can handle at least all the
      legal Ada programs in the ACVC test-suite.

      5.  Runtime debugger -- The instrumented program output by (4)
      can be run with a special debugger that allows program debugging
      based on formal specifications.

      All tools have been developed in Ada and are therefore extremely
      portable.  Anna has been ported to many platforms, details of
      which can be obtained from the person who handles Anna releases.
      You can send e-mail to [e-mail] for answers
      to such questions.  Actually, there is also a mailing list --
      [e-mail].  Send e-mail to the earlier address
      if you want to get on this list.

      One could view Anna and its toolset as a *very* significant
      enhancement of assertions that are provided in languages such as
      C (using the assert statement).  The enhancements are in the
      form of both (1) many more high level specification constructs;
      and (2) more sophisticated tool support.

      However, there are those who would not even wish to compare Anna
      with C assertions!  :-)

      The Anna tools may be found on the machine anna.stanford.edu in
      the anonymous ftp directory pub/anna.

11) What is DRAGOON, and where can I get it?

      (from [e-mail] (Drew Johnson))

      DRAGOON is a language, implemented as an Ada preprocessor (i.e.,
      generates pure Ada).  DRAGOON supports the development of Ada in
      a truly object-oriented manner, including complete support for
      multiple inheritance.  A very nice feature of DRAGOON not found
      in many OO languages is the concept of "behavioral" inheritance.
      This allows you to keep the concurrent behavior of object
      separated from the object class hierarchy.

      The book by Colin Atkinson, "Object-Oriented Reuse, Concurrency
      and Distribution: An Ada-Based Approach" (ACM Press, 1991, ISBN:
      0201565277), is very well written and describes the language
      succinctly and completely.

      For a copy of the preprocessor, you can contact:

      Mr. Andrea Di Maio
      TXT Ingegneria Informatica S.p.A.
      Via Socrate, 41
      20128 Milan, ITALY
      0039-2-27001001

12) Does anyone have a list of commercial Ada projects?

      (from the AdaIC)

      The Ada Information Clearinghouse maintains a list of Ada
      projects that have submitted information for the AdaIC's Ada
      Usage Database.  It is only a sample of Ada projects, but it
      includes both commercial and government-related projects.
      Details on contacting the AdaIC are below (question 15).

13) Are there versions of lex and yacc that generate Ada code?

      (from [e-mail] (Drew Johnson))

      The Arcadia project produced aflex and yacc, that are written in
      Ada and produce Ada code.  These can be found in the STARS
      repository (source.asset.com -- see below), as well as other
      sites.

14) What ftp sites exist that contain information about Ada or Ada source?

      (from [e-mail] (Drew Johnson))

      Ada Software Repository: wsmr-simtel20.army.mil
        Internet address: 192.88.110.20
      Mirror of Ada Software Repository: wuarchive.wustl.edu
        Internet address: 128.252.135.4
      AJPO and AdaIC repository: ajpo.sei.cmu.edu
        Internet address: 128.237.2.253
      Source for aflex and ayacc: liege.ics.uci.edu (~ftp/pub/irus)
        Internet address: 128.195.1.5, 128.195.13.1
      European Repository: cnam.cnam.fr
        Internet address: 192.33.159.6
      STARS (Software Technology for Adaptable, Reliable Systems):
      source.asset.com
        Internet Address: 192.131.125.10
      Unisys/STARS source: stars.rosslyn.unisys.com
        Internet Address: 128.126.164.2

15) What organizations exist that deal with Ada and Ada issues? (Long)

      (from AdaIC)

      Ada Joint Program Office (AJPO)
      The AJPO is part of the Department of Defense; it facilitates
      the implementation of the DoD's Software Initiative (Ada)
      throughout the Services, and maintains the integrity of the Ada
      language.  (The AJPO sponsors the AdaIC.)

      The address is:
      Ada Joint Program Office
      The Pentagon, 3E118
      Washington, DC 20301-3081
      703/614-0208 (autovon 224-0208)
      fax: [phone]

      The current Director and Deputy Directors are:

      Director:                         Dr. John Solomond
                                          ([e-mail])
      Air Force Deputy Director:        Maj M. Dirk Rogers
                                          ([e-mail])
      Navy Deputy Director:             Mr. W. Currie Colket
                                          ([e-mail])
      Army Deputy Director:             vacant

      Ada Information Clearinghouse (AdaIC)
      (from [e-mail] (Michele L. Kee))

      Ada Information Clearinghouse
      c/o IIT Research Institute
      4600 Forbes Boulevard
      Lanham, MD 20906-4320
      1-800-AdaIC-11, 703/685-1477; fax: [phone]

      The Ada Information Clearinghouse (AdaIC) provides a full
      spectrum of information on Ada to anyone interested in finding
      out more about the programming language.  IIT Research Institute
      operates the AdaIC for the Ada Joint Program Office (AJPO).  The
      AdaIC publishes a quarterly newsletter, which contains current
      news, Ada conference reports, announcements from the AJPO
      Director, and articles on projects using Ada.  If you would like
      to receive a copy of the AdaIC newsletter, please call and
      request a subscription.  There's no charge.  The AdaIC also
      regularly updates and publishes more than 70 separate
      information flyers.  Flyer topics include:

           Ada Validated Compilers
           Ada News and Current Events
           Ada Usage
           Ada 9X Project
           On-line sources of Ada Information
           Ada Bibliographies
           Ada Compiler Validation and Evaluation
           Resources for Ada Education and Training
           Ada Software, Tools, and Interfaces
           Ada Regulations, Policies, and Mandates
           Ada Historical Information

      One of the most commonly requested flyers is the Validated
      Compilers List.  This list, which is updated monthly, contains
      Ada compilers that have been validated by the AJPO.  For the
      most current information on validated Ada compilers, contact the
      AdaIC.

      *Practically all AdaIC flyers are available via anonymous ftp
      from the AJPO host (ajpo.sei.cmu.edu, in the public/
      directories).*

      Association of Computing Machinery's Special Interest Group on
      Ada (ACM SIGAda):

      SIGAda's bimonthly publication is Ada Letters: Non-members $37;
      (Annual ACM membership dues, $71; students, $21).  $15 per year
      to ACM members; $10 per year ACM student members.

      Association for Computing Machinery, Inc.
      1515 Broadway
      New York, NY 10036
      212/869-7440

      SIGAda also has a number of committees and working groups on a
      variety of topics.

      ISO Working Group 9 (ISO-IEC/JTC1/SC22/WG9):
      This is a working group that deals with Ada within the
      Internation Standardization Organization.  Within WG-9, are
      several Rapporteur (rap) groups:

      CRG: Character Rapporteur Group - International Character Sets
      RRG: Real-Time Rapporteur Group - ExTRA
      NRG: Numerics Rapporteur Group - NUMWG packages
      SRG: SQL Interfaces Rapporteur Group - SAMeDL
      IRG: Information Systems Rapporteur Group - Decimal Arithmetic
      XRG: Ada 9X Rapporteur Group

      Ada Rapporteur Group (ARG):
      (from [e-mail])

      This is the group responsible for evaluating comments on the Ada
      standard.  Officially, the group is only developing a technical
      report addressing comments and questions concerning the ISO
      standard for Ada.  (Arcane ISO rules prevent the ARG or WG9 from
      issuing "official" interpretations of a standard.)  In practice,
      when a response to a comment is approved by WG9, the response is
      taken into account by the Ada Validation Office and affects the
      test suite.  The documents containing comments on the standard
      and ARG responses are called "Ada Commentaries" and are given
      numbers of the form AI-ddddd/vv, where vv is a version number.

      Comments and questions about the Ada standard should be sent to
      [e-mail], using the format specified in the
      Ada standard.  You can receive e-mail notification of an update
      to a commentary (optionally including the text of the commentary)
      by sending a request to [e-mail].
      Commentaries are generally updated only a few times each year.
      The text of all commentaries is available by anonymous ftp from
      the AJPO site in the account public/ada-comment.  A detailed
      discussion of ARG procedures and the format of commentaries can
      be found in the ada-comment account in the file
      arg-procedures.doc.  A reformatted copy of the Reference Manual
      that includes WG9-approved commentaries is available from Karl
      Nyberg ([e-mail]).

      Uniformity Rapporteur Group (URG):
      (from [e-mail] (David Emery))

      Responsible for evaluating Uniformity Issues (UIs).  UIs
      specify/recommend specific choices for the compiler implementor,
      where the language permits implementation freedom.  The
      "canonical example" is UI-8, on integer types.  This UI
      recommends that integers be at least 32 bits, and provides names
      for the other predefined integer types.  The goal of the URG and
      the UI's is to further Ada portability by providing uniform
      implementations of implementation-dependent features commonly
      used by Ada applications.

16) What cheap (<500$) Ada compilers are available?

      What follows is absolutely *not* exhaustive, but inexpensive
      compilers are available, and some vendors offer educational
      discounts.  Among those offering educational discounts are
      Alsys, DDC-I, Encore, Harris, IBM, Irvine Compiler, Meridian,
      PSS, Tartan, and TeleSoft.

      Meridian
      Among choices for inexpensive compilers, Meridian offers one for
      $99.  (Meridian Software Systems, 10 Pasteur Street, Irvine, CA
      92718; contact: Jim Smith 800/221-2522, 714/727-0700)

      Alsys (US pricing only):
      FirstAda for 286 DOS is $595.  It'll run on 286 and higher, and
      will generate applications for any x86 PC.  Comes with a full
      toolset.  Alsys does run specials on it periodically.  Call
      Scott Dorman at 617/270-0030 for more info.

      Alsys offers the same compilation system for $144 to qualified
      educational institutions under its LEAP program.  The program
      also offers substantial educational discounts on other Alsys
      products, as well as site license arrangements.  Contact Kathy
      Ruggiero at 617/270-0030 for more info.

17) Are there any dialup BBS systems that deal with Ada?

      AdaIC BBS: (US) 703/614-0215 AUTOVON: 224-0215

      Ada 9X: (US) 800-Ada9X25 301/459-8939

      (from [e-mail] (Kurt Olender))

      AdaNet BBS: This is a free service that maintains e-mail
      connections for people not on the internet, an Ada source code
      repository, and a selection of other on-line Ada-related
      documents.  It is sponsored by NASA.  Call 800/444-1458 to
      register for access.

      (from [e-mail] (Susan Carlson))
      (Caveat: Telephone numbers can change without notice.  If we
      find out a number doesn't work, we'll note that, but leave the
      entry in until we're sure the service has actually been
      discontinued.  If you are aware of a better number, please let
      us know.)

      Naval Computer Telecommunications Command
      Tel: [phone]

      Air Force Software Technology Support Center (STSC) BBS
      Tel: [phone] or DSN 458-7553
      Baud: 2400, 1200, 300
      Bits: 8
      Parity: None
      Stop Bits: 1

      ACM SIGAda Performance Issues Working Group
      PIWG Ada Benchmarks BBS
      Tel: [phone]

      AFSC MCCR Ada -- Air Force Policy
      Tel: [phone] (?? wasn't working on 2 Nov 92)

      Embedded Systems Programming Magazine BBS
      Tel: [phone]

      Ada Language System/Navy
      Tel: [phone]
      Baud: 2400/1200/300
      Bits: 8
      Parity: None
      Stop Bits: 1

18) Does anyone know where I can get bindings for Ada?  X-Windows?
    Others?  (See 22 and 23 for specific reference to POSIX.)

      General
      The AdaIC (question 15, above) has a report on "Available Ada
      Bindings".  It can be ordered in hardcopy as flyer S82, and it
      can be downloaded from the AdaIC Bulletin Board (703/614-0215)
      as BINDINGS.HLP.  It's also available by anonyomous ftp on the
      AJPO host (ajpo.sei.cmu.edu).

      X-Windows
      (from [e-mail] (Drew Johnson))

      This question turns out to be pretty darn hard to answer easily.
      There are at least three variables that need to be filled:

      1) platform where you are going to be running.
      2) compiler you would like to use.
      3) Level/flavor of X you would like to run (e.g., just need
      bindings to Xlib, want Openlook as opposed to Motif, etc).

      Once you fill all three of the above, then you can start to get
      answers.  In order to keep the answer brief, I am simply going
      to list companies that offer such products, and locations where
      free versions are available.

      Before I give the list, I think a little history is in order.
      The first Xlib bindings that were publically available were done
      by SAIC for STARS.  This implementation had many bugs, but it
      was there, and it was free.  I believe that this version was
      eventually withdrawn from the STARS repository, and has now been
      replaced with a better one.  In addition, SAIC has done an Xt
      implementation based on these Xlib bindings (also for STARS).
      NOTE: the above description may well be inaccurate, and I
      welcome corrections.

      Now, for the list.
      NOTE: this list is currently "off the top of my head", and I
      welcome the addition of details and/or corrections.  I currently
      don't have time to go back through the comp.lang.ada archives to
      get full contact info on the companies I am listing below.  I am
      counting on their vigilance to see the FAQ and send me info.

      First off, there is a pretty complete list of available bindings
      for X as well as other stuff at the Ada IC.
      site: ajpo.sei.cmu.edu
      location: /public/ada-info/bindings.hlp.06Oct92
      access: anonymous FTP

      Free versions:
      STARS: bindings to Xlib and Xt.  freely available via ftp on
      source.asset.com

      Non-free versions:
      SERC: bindings to Xlib/Xt/Motif
      contact: well![e-mail] (Scott Cleveland)

      Verdix: bindings to Xlib/Xt/Motif
      (Note that bindings to Xview are included with the SunAda Sun4
      compiler)
      contact: [e-mail] (Paul Moskowitz)

      ATC: bindings to Xlib/Xt/Motif
      contact: ???

      Telesoft: bindings to Xlib/Xt/Motif (TeleWindows)
      (Note that bindings to Xview are included with the TeleSoft Sun4
      compiler)
      contact: [e-mail]

      X-based GUI (Graphical User Interface) Builders:
      Objective (OIS): Screen Machine
      contact: Phil Carrasco (703/264-1900)

      TeleSoft: TeleUSE
      contact: [e-mail]

      EVB software: GRAMMI
      contact: [e-mail]

      Sun Microsystems: DevGuide
      contact: ???

      SERC: UIL-to-Ada code generator
      (not really a GUI-builder, but works with several builders to
      generate Ada instead of other languages).
      contact: well![e-mail] (Scott Cleveland)

19) Is there a list of Ada compiler vendor e-mail contacts?

      (from [e-mail] (Drew Johnson))

      Alsys sales (e-mail contact only): [e-mail] (Tom Erickson)
      Alsys sales (voice) Scott Dorman
      Tel: [phone]

      Convex questions: [e-mail] (Brian Allison)
      Tel: [phone]

      Cray questions: [e-mail] (Dave Thersleff)
      Tel: [phone]
      Cray sales: [e-mail] (Sylvia Crain)
      Tel: [phone]

      Harris questions: [e-mail] (Jeff Hollensen)

      IBM/Ada questions: [e-mail] (Don Malcho)
      Tel: [phone]

      Intermetrics questions: [e-mail] (Mike Ryer)

      Irvine Compiler Corp (ICC) questions: [e-mail]

      Tartan questions: [e-mail] (Susan Englert)
      Tel: [phone]

      Telesoft questions: [e-mail]
      Tel: [phone]
      TeleSoft Sales: [e-mail] (Philippe Collard)
      Tel: [phone]

      Verdix questions: [e-mail] (Drew Johnson)
      Verdix sales information: [e-mail] (Paul Moskowitz)
      Tel: 800-BUY-VADS

                                    ***
concluded in comp.lang.ada Frequently Asked Questions (FAQ) part 2 of 2
                                (cla-faq2)
                                    ***

Archive-name: comp-lang-ada/cla-faq2


comp.lang.ada Frequently Asked Questions part 2 of 2

Effective date: 4 JUN 93

20) Is there a list of good Ada books?

      Just for a list of texts, etc. (no evaluations or
      recommendations), you might take a look at the ADABOOKS.HLP file
      on the AdaIC Bulletin Board and in the public/ada-info directory
      on the AJPO host (ajpo.sei.cmu.edu).

      Books for use in class (and others):
      (from [e-mail] (Michael B. Feldman))

      As co-chair of the SIGAda Education Committee, and a denizen of
      the Internet newsgroups, I am often asked to give references for
      "Ada textbooks."  This list responds to these many queries.  It
      is far from exhaustive, merely a selected list of 26 books being
      used successfully in undergraduate computer science courses.

      The six books in the Group 1 are written especially for students
      without programming experience, who are learning Ada as their
      first language.  Most of these can also cover at least part of a
      typical CS2-level course.  The seven books in Group 2 use Ada as
      their language of discourse but are "subject-oriented:" data
      structures, file structures, compilers, comparative languages.
      The thirteen books in Group 3 are either "Ada books" focusing on
      the language features or more general books that use Ada, at
      least in part, but do not fit obviously into a standard
      curriculum "pigeonhole."

      I invite you to add to the list.  Please write your annotated
      entry in the form I have used here and write or e-mail it to me.
      I will include it in my next version and credit you as a
      co-compiler of the list.

      Disclaimers: I wrote two of the texts listed here; I hope the
      annotations are impartial enough.  And any annotated
      bibliography is selective and opinionated.  Your mileage may
      vary.

      Group 1: Books Suitable for a First Course in Programming

      Bover, D.C.C., K.J. Maciuas, and M.J. Oudshoorn.
      Ada: A First Course in Programming and Software Engineering.
      Addison-Wesley, 1992.
      This work is, to our knowledge, the first Ada book to emerge
      from Australia, from a group of authors with much collective
      experience in teaching Ada to first-year students.  A number of
      interesting examples are presented, for example, an Othello
      game.  The book is full of gentle humor, a definite advantage in
      a world of dry and serious texts.  In the book's favor is the
      large number of complete programs.  On the other hand, it is
      rather "European" in its terseness; American teachers may miss
      the pedagogical apparatus and "hand-holding" typically found in
      today's CS1 books.  Generic units are hardly mentioned.

      Culwin, F.
      Ada: a Developmental Approach.
      Prentice-Hall, 1992.
      This work introduces Ada along with a good first-year approach
      to software development methodology.  Much attention is paid to
      program design, documentation, and testing.  Enough material is
      present in data structures and algorithm analysis is present to
      carry a CS2 course.  A drawback of the book is that the first
      third is quite "Pascal-like" in its presentation order:
      procedures, including nested ones, are presented rather early,
      and packages are deferred until nearly the middle of the book.
      This is certainly not a fatal flaw, but it will frustrate
      teachers wishing a more package-oriented presentation.  The
      programs and solutions are apparently available from the author.

      Feldman, M.B., and E.B. Koffman.
      Ada: Problem Solving and Program Design.
      Addison-Wesley, 1991.
      This work combines the successful material from Koffman's CS1
      pedagogy with a software-engineering-oriented Ada presentation
      order.  Packages are introduced early and emphasized heavily;
      chapters on abstract data types, unconstrained arrays, generics,
      recursion, and dynamic data structures appear later.  The last
      five chapters, combined with some language-independent algorithm
      theory, can serve as the basis of a CS2 course.  A diskette with
      all the fully-worked packages and examples (about 180) is
      included; the instructor's manual contains a diskette with
      project solutions.

      Savitch, W.J. and C.G. Petersen.
      Ada: an Introduction to the Art and Science of Programming.
      Benjamin/Cummings, 1992.
      This is a straightforward adaptation of the well-known Savitch
      Pascal books.  Ada is introduced in a Pascal-like order, with
      subtypes and packages introduced halfway through the book.  This
      is purely a CS1 book.  The final chapter covers dynamic data
      structures.  There is no coverage of unconstrained array types;
      generics are introduced at the halfway point to explain Text_IO,
      then dropped until the final chapter.  The authors intended this
      book to provide a painless transition to Ada for teachers of
      Pascal; one wishes they had taken advantage of the chance to
      show some of the interesting Ada concepts as well.  Program
      examples from the text are available on disk, but only as part
      of the instructor's manual; a solutions disk is available for a
      fee from the authors.

      Skansholm, J.
      Ada from the Beginning.
      Addison Wesley, 1988.
      This book was one of the first to use Ada with CS1-style
      pedagogy.  There are excellent sections on the idiosyncracies of
      interactive I/O (a problem in all languages), and a sufficient
      number of fully-worked examples to satisfy students.  Generics,
      linked lists and recursion are covered at the end; there is no
      tasking coverage, but one would not expect this at CS1-level.

      Volper, D., and M. Katz.
      Introduction to Programming Using Ada.
      Prentice-Hall, 1990.
      This book uses a heavily "spiraled" approach to Ada, and is
      designed for a 2-semester course, covering nearly all of Ada
      eventually.  There are lots of fully-coded examples, and good
      pedagogical sections on testing, coding style, etc.  If you like
      spiraling, you'll like this.  The down side is that you can't
      find all you need on a given subject in one place.  It's at the
      other end of the scale from the "Ada books" that follow the Ada
      Language Reference Manual (LRM) order.

      Group 2: Other Books Intended for Undergraduate Courses

      Ben-Ari, M.
      Principles of Concurrent and Distributed Programming.
      Prentice-Hall 1990.  (OS/concurrency)
      In my opinion, this is the best introduction to concurrency on
      the market.  Ada notation is used for everything, but the focus
      is on concurrency and not on Ada constructs per se.  I liked the
      CoPascal notation of the first edition better, but this book is
      still great.  A software disk is promised in the preface; I had
      to work quite hard to get it from the publisher, which finally
      had to express-ship it from England.  The software comes with a
      tiny Ada-ish interpreter, complete with Pascal source code,
      adapted from Wirth's Pascal/S via CoPascal.  There are also some
      real Ada programs, most of which I've tested and found correct
      and portable.

      Feldman, M.B.
      Data Structures with Ada.
      Prentice Hall, 1985 (now distributed by Addison-Wesley).
      (CS2/data structures)
      This book is a reasonable approximation to a modern CS2 book:
      "big O" analysis, linked lists, queues and stacks, graphs,
      trees, hash methods, and sorting, are all covered.  The Ada is a
      bit old-fashioned, especially the lack of generics; the book was
      published before compilers could handle generics.  The packages
      and other programs are available free from the author.  The book
      is currently under revision with Addison-Wesley and should
      appear in 1993.

      Fischer, C., and R. LeBlanc.
      Crafting a Compiler.
      Benjamin Cummings, 1988.  (compilers)
      This book uses Ada as its language of discourse and Ada/CS, a
      usefully large Ada subset, as the language being compiled.  If
      you can get the "plain Pascal" tool software by ftp from the
      authors, you'll have a good translator-writing toolset.  Skip
      the Turbo Pascal diskette version, which is missing too many
      pieces to be useful.  I've used the book since it came out with
      both undergrad and graduate compiler courses; it embodies a good
      blend of theory and "how it's really done" coding.  Students
      like it.  The authors have recently published a second version,
      which uses C as its coding language but retains Ada/CS as the
      language being compiled.

      Lomuto, N.
      Problem-Solving Methods with Examples in Ada.
      Prentice-Hall, 1987.  (algorithms)
      Inspired by Polya's classic How to Solve It, this book can make
      a nice addition to an Ada-oriented algorithms course.  It makes
      too many assumptions about students' programming background to
      use as a CS1 book, and doesn't teach enough Ada to be an "Ada
      book."  But it makes nice reading for students sophisticated
      enough to handle it.  I'd classify it as similar to Bentley's
      Programming Pearls.

      Miller, N.E. and C.G. Petersen.
      File Structures with Ada.
      Benjamin/Cummings, 1990.  (file structures)
      Designed for a straightforward ACM-curriculum file structures
      course, this book succeeds at what it does.  There are good
      discussions of ISAM and B-tree organizations.  The software can
      be purchased a low cost from the authors; it seems to
      approximate in Ada all those C-based file packages advertised in
      programmer-oriented trade publications.

      Schneider, G.M., and S.C. Bruell.
      Concepts in Data Structures and Software Development (with Ada
      Supplement by P. Texel).
      West, 1991.  (CS2/data structures)
      This work is not, strictly speaking, an Ada book; rather, it is
      a solid, language-independent approach to modern CS2.  The
      language of discourse in the book is a Pascal-like ADT language
      rather like Modula-2 in style; some examples are coded in legal
      Pascal.  The Ada supplement makes it usable in an Ada-based
      course, but the supplement is rather too terse (100 pages of
      large type) for my taste, and insufficiently well keyed to the
      book chapters.  The supplement's effectiveness would be greatly
      enhanced by full translations to Ada of a large number of the
      book's examples.

      Sebesta, R.W.
      Concepts of Programming Languages.
      Benjamin Cummings, 1989.  (comparative languages)
      If you've been around for a while, you might remember the late
      Mark Elson's 1975 book by the same title.  This is similar: a
      concept-by- concept presentation, with -- in each chapter --
      examples taken from several languages.  There is a nice
      impartial presentation of Ada along with the others.  I
      especially like the chapters on abstraction and exception
      handling.  The book covers -- comparatively, of course -- most
      of the lanuages you'd like to see, including C, Lisp, Smalltalk,
      etc., with nice historical chapters as well.  The book is
      readable; my students like it.  Our undergraduate and graduate
      courses both use it as a base text.

      Group 3: A Selection of Other Ada-Related Books

      Barnes, J.
      Programming in Ada.  (3rd edition)
      Addison Wesley, 1989.
      Barnes' work has been one of the most popular "Ada books."  Some
      students find it hard to see how the pieces fit together from
      Barnes' often fragmentary examples; it is difficult to find
      complete, fully- worked out, compilable programs.  A version is
      available with the entire Ada Language Reference Manual bound in
      as an appendix.

      Booch, G.
      Object-Oriented Design, with Applications.
      Benjamin Cummings, 1991.
      This is a good comparative introduction to the "object-oriented
      (OO)" concept.  The first half gives a balanced presentation of
      the issues in OO Design; the second half gives nontrivial
      examples from Ada, Smalltalk, C++, CLOS, and Object Pascal.  The
      author tries to sort out the difference between object-based
      (weak inheritance, like Ada) and object-oriented (like C++)
      languages.  My only real complaint is that Booch should have
      worked out at least some of his case studies using several
      different languages, to highlight the similarities and
      differences in the language structures.  As it is, each case
      study is done in only a single language.  The good news is that
      the book is remarkably free of the hyperbolic claims one
      sometimes finds in the OO literature.  I think this book could
      be used successfully in a second- level comparative languages
      course.

      Booch, G.
      Software Components with Ada.
      Benjamin Cummings, 1987.
      This work is an encyclopedic presentation of data structure
      packages from Booch's OOD point of view.  It is great for those
      who love taxonomies.  It's not for the faint-hearted, because
      the volume of material can be overwhelming.  It could serve as a
      text for an advanced data structures course, but it's thin in
      "big O" analysis and other algorithm-theory matters.  The book
      is keyed to the (purchasable) Booch Components.

      Booch, G.
      Software Engineering with Ada.  (2nd edition)
      Benjamin Cummings 1987.
      Another of the classical "Ada books."  Introduces Booch's OOD
      ideas.  Not for use to introduce Ada to novices, in my opinion;
      there are some nice fully-worked case studies but they begin too
      far into the book, after long sections on design, philosophy,
      and language elements.  The earlier chapters contain too much
      fragmentary code, a common flaw in books that follow the LRM
      order.

      Bryan, D.L., and G.O. Mendal.
      Exploring Ada, Volumes 1 and 2.
      Prentice-Hall, 1990 and 1992 respectively.
      This is an excellent study of some of the interesting nooks and
      crannies of Ada; it sometimes gets tricky and
      "language-lawyerly."  Volume 2 takes up tasking, generics,
      exceptions, derived types, scope and visibility; Volume 1 covers
      everything else.  The programs are short and narrowly focused on
      specific language issues.  If you like Bryan's "Dear Ada" column
      in Ada Letters, you'll like this book.  It is certainly not a
      book for beginners, but great fun for those who know Ada already
      and wish to explore.

      Burns, A.
      Concurrent Programming in Ada.
      Cambridge University Press, 1985.
      I used this book for years in my concurrency course.  It's
      roughly equivalent to Gehani's book, but its age is showing.
      Cambridge Press is not always easy to get books from, especially
      in the US.

      Cohen, N.
      Ada as a Second Language.
      McGraw Hill, 1986.
      This book is a quite comprehensive exploration of Ada which
      follows the LRM in its presentation order.  My graduate students
      like it because it is more detailed and complete than
      alternative texts.  It's an excellent book for students who know
      their languages and want to study all of Ada.  There are good
      discussions of "why's and wherefore's" and many long,
      fully-worked examples.

      Gauthier, M.
      Ada: Un Apprentissage (in French).
      Dunod, 1989.
      I found this an especially interesting, almost philosophical
      approach to Ada.  The first section presents Ada in the context
      of more general laguage principles: types, genericity,
      reusability.  The second section introduces testing and
      documentation concerns, as well as tasking; the third considers
      generics and variant records in the more general context of
      polymorphism.  For mature Ada students in the French-speaking
      world, and others who can follow technical French, this book can
      serve as a different slant on the conventional presentations of
      the language.  An English translation would be a real
      contribution to the Ada literature.

      Gehani, N.
      Ada: an Advanced Introduction (2nd edition).
      Prentice-Hall, 1989.
      I've always liked Gehani's literate writing style; he knows his
      languages and treats Ada in an interesting, mature, and balanced
      fashion.  This book comes with a diskette sealed in the back of
      the book, which is advantageous because the book has numerous
      nontrivial, fully- worked examples.

      Gehani, N.
      Ada: Concurrent Programming (2nd edition).
      Silicon Press, 1991.
      This is a less formal, more Ada-oriented presentation of
      concurrency than the Ben-Ari work.  I use both books in my
      concurrency course; its real strength is the large number of
      nontrivial, fully worked examples.  Gehani offers a nice
      critique of the tasking model from the point of view of an OS
      person.  The preface promises the availability of a software
      disk from the publisher.

      Nyberg, K.
      The Annotated Ada Reference Manual.  (2nd edition)
      Grebyn Corporation, 1991.
      This is the definitive work on Ada legalities, because it
      presents not only the full text of the LRM but also the official
      Ada Interpretations.  These commentaries, interleaved with the
      LRM text, have been approved and promulgated by the Ada Board
      and the various standards organizations, and are binding upon
      compiler developers.  I recommend this book as an essential
      volume in the library of every serious Ada enthusiast.

      Shumate, K.
      Understanding Ada.  (2nd edition)
      John Wiley, 1989.
      This would make a CS1 book if it included more overall pedagogy,
      independent of language constructs.  Otherwise it is a nice
      introduction to Ada in fairly gentle steps.  Lots of completely
      worked examples, right from the start.  Doesn't follow the LRM
      order, which is great.

      Watt, D.A., B.A. Wichmann, and W. Findlay.
      Ada Language and Methodology.
      Prentice-Hall, 1987.
      This work presents some interesting programming projects, and
      the coverage of design and testing--at the level of a first-year
      student--is quite good.  The first third of the book
      concentrates heavily on classical control and data structures,
      leaving exceptions and packages until the "programming in the
      large" material in the second third.  CS2 teachers will find too
      little concentration on algorithm analysis.  On the other hand,
      tasking and machine-dependent programming are covered.  Like the
      Shumate work, this book would make a suitable introduction to
      Ada for students with a semester or so of programming
      experience; it "jumps in" too quickly to satisfy the needs of
      neophytes and is not well-tailored to CS1 or CS2 needs.

21) Where can I get language translators?

      The AdaIC maintains a Products and Tools Database on its
      bulletin board (703/614-0215), and one of the categories is
      translators.  (The list of products should not be considered
      exhaustive; if you wish to suggest additions, please contact the
      AdaIC.)  Besides access to the database via the bulletin board,
      you can also call the AdaIC (800-AdaIC-11 or 703/685-1477) and
      ask for a customized search.

      In addition to all the usual caveats, however, it should also be
      noted that translation itself is a controversial issue.

      When a project makes the transition to Ada from some other
      language, one question that arises is whether to translate older
      code into Ada.  Among the immediate considerations are how much
      of the code can in fact be translated by a program intended for
      that purpose, versus how much will still require re-coding by
      hand.  And will the translated code will suffer a significant
      loss in speed of execution?  Further, a project must consider
      whether the translated code will reflect sound software
      engineering and be readily understandable and modifiable.  Or
      will it be merely "Fortranized Ada" or "Cobolized Ada", or the
      like, possibly retaining limitations present in the earlier
      code?  Portability is also a problem.

      The resolution of such issues will require an understanding of
      the earlier code, an appreciation of the similarities and
      differences between its language and Ada, and an evaluation of
      the translation program under consideration.

22) What is the status of the POSIX/Ada work?

      (from [e-mail] (dave emery))

      The IEEE approved IEEE Standard 1003.5-1992 in June 1992.  This
      is the Ada Binding to the facilities defined in ISO
      9945-1:1989/IEEE 1003.1-1990, the POSIX System Services.

      IEEE Standards Committee P1003.5 is now working on Ada bindings
      to IEEE draft standards 1003.4, Real-Time Extensions and
      1003.4a, Threads Extensions.  Current plans call for an IEEE
      ballot in October 1993, with IEEE approval in September 1995.
      For more information, contact the P1003.5 Chairman, Jim Lonjers
      ([e-mail], 805/987-9457).

23) How can I get a copy of POSIX/Ada?  Is it available via FTP?

      (from [e-mail] (dave emery))

      You can buy a copy of the standard from the IEEE.  The order
      number is "SH 15354", and the mailing address is "IEEE Service
      Center, 445 Hoes Lane, Piscataway, NJ 08855-1331".  They will
      accept credit-card orders at 1-800/678-4333.  The cost is $62.50
      + $5.00 s/h ($43.75 + $4.00 s/h for IEEE Members).

      Current IEEE policy prohibits electronic distribution of IEEE
      standards.  Proceeds from the sale of IEEE standards help
      support the IEEE standards program.

      The POSIX P1003.5 committee is trying to work out an arrangement
      with the IEEE to make the POSIX/Ada package specifications
      available for distribution via email and anonymous FTP.

24) Where can I get Ada benchmark programs?

      In addition to the information below, you may also wish to look
      at the AdaIC flyer "How to Obtain Benchmark Performance Test
      Suites and Results", flyer V15, file benchmrk.hlp.<date> on the
      AJPO Host (ajpo.sei.cmu.edu).  For more on the AdaIC and
      downloading files, see questions 14), 15), and 25).

      (from [e-mail] (Patrick Donohoe))

      The Ada Evaluation System:

      The Ada Evaluation System (AES) may be obtained from the British
      Standards Institute at the following address:

           Software Product Services
           Software Engineering Department
           BSIQA
           P.O. Box 375
           Milton Keynes MK14 6LL
           United Kingdom
           Tel: [phone]
           UUCP: [e-mail]
           (Internet: bsiqa![e-mail])

      As of February 1993, the current version is the DIY-MAPSE-01
      version.  It is available at a cost of 3,000 pounds sterling.
      BSI also offers a validation service at a cost of 24,000 pounds
      sterling.  Principal documents are a User's Manual, a Reference
      Manual, and a Test Description Document.

      The Ada Evaluation System (AES) will be merged with the Ada
      Compiler Evaluation Capability (ACEC) under a joint agreement
      between the Ministry of Defence of the United Kingdom and the
      Department of Defense of the United States that was signed in
      June of 1991.  The merged product will be released as version
      4.0 of the ACEC; as of March 1993, the expected release time
      was the third or fourth quarter of 1993.

      The Ada Compiler Evaluation Capability:

      The Ada Compiler Evaluation Capability (ACEC) may be obtained
      from:

           Data and Analysis Center for Software (DACS)
           P.O. Box 120
           Utica, NY 13503
           Tel: [phone]
           Internet: [e-mail]

      As of February 1993, the current release of the ACEC is 3.0.
      There are three documents: the User's Guide, the Reader's Guide,
      and the Version Description Document.  The total cost for the
      software and documentation is 100 US dollars.  (Release 3.0 of
      the ACEC is not the merged AES-ACEC product referred to above.)

      Hartstone Benchmarks:

      Electronic mail requests for Hartstone should be sent to the
      following Internet address:

           [e-mail]

      The reply message will contain full details of how to obtain
      source code and documentation by various means, including
      anonymous ftp.  There is no charge for the Hartstone source
      code.

      For people without Internet access, the address to send requests
      to is:

           REST Transition Services
           Software Engineering Institute
           Carnegie Mellon University
           Pittsburgh, PA 15213-3890
           Phone: [phone]

      Hartstone source code may also be retrieved from the PIWG
      bulletin board.  (See below.)

      The PIWG Benchmarks:

      The ACM Performance Issues Working Group (PIWG) benchmarks may
      be obtained in one of three ways:

           1.  Via anonymous ftp from the ajpo.sei.cmu.edu machine.
               Users should issue the command "ftp ajpo.sei.cmu.edu"
               and log in using the word "anonymous" as the login name
               and an identifying string (e.g., the user's e-mail
               address) as password.  Change directory ("cd" command)
               to the "public/piwg/piwg_11_92" directory and use the
               ftp file-transfer commands to retrieve the files.  The
               README file contains information about using the
               benchmarks.

           2.  Via the PIWG bulletin board.
               Ideally, users should access this from a PC (rather
               than a dumb terminal) using a modem capable of sending
               and receiving at 1200 baud or higher.  The number of
               the bulletin board is 412/268-7020.  Once connected to
               the bulletin board, users will be able to navigate
               their way around the system using simple menus that the
               system provides.  The point of contact for this service
               is Gene Rindels, 412/268-6728.

           3.  Via a written request or telephone request to the
               following service:

                   PIWG Distribution
                   Software Engineering Institute
                   Carnegie Mellon University
                   Pittsburgh, PA 15213-3890
                   Tel: [phone]

               As of February 1993, the current release of the PIWG
               suite is the one dated 11/92.  There is no charge for
               the PIWG benchmarks.  Documentation for the PIWG
               benchmarks consists principally of the READ.ME file
               distributed with the suite and comments in the
               individual test programs and command files.  There is
               also additional information about the PIWG suite in the
               Winter 1990 special edition of Ada Letters (Vol. X,
               No. 3, special edition on Ada Performance Issues).

25) The AJPO host has a lot of Ada information files available for
    downloading by anonymous FTP.  But I don't have FTP service on the
    Internet host where I have an account.  Is there any way I can get
    those files?

      The AJPO host, ajpo.sei.cmu.edu, will provide mail-server
      capabilities on an experimental basis.  The available services
      provided by this automatic mail server are: services, Re, help,
      info, man, directory, and file-request.  To request a service,
      send e-mail to "[e-mail]" and place its name in
      the Subject line of the mail message, followed by any needed
      parameters.  The mail server will respond to your request with
      either the information you requested or an error message.

      The following are common examples on how to request services
      from the AJPO host mail server:

      ----------------------------------------------------------------------
      1) To get "help" --

      To: [e-mail]
      Subject: help

      ----------------------------------------------------------------------

      2) To get "man" pages of a particular service, such as "directory" --

      To: [e-mail]
      Subject: man directory

      This service takes as a parameter the name of a service, and
      returns a manual page on that service.

      ----------------------------------------------------------------------

      3) To get a "directory" listing of the AJPO anonymous ftp area
      (/public) --

      To: [e-mail]
      Subject: directory

      The "directory" service takes as an optional parameter a file or
      directory name, and returns the results of an "ls -l" on that
      parameter.  For example, to get a listing of the
      /public/ada-info directory you would submit a message with the
      Subject of:

      Subject: directory ada-info

      The filename pattern may include wildcards as defined by the C
      shell.  For example, to get a listing of the /public directories
      beginning with "p" you would submit a message with the Subject
      of:

      Subject: directory p*

      ----------------------------------------------------------------------

      4) Use "file-request" to get /public/README file --

      To: [e-mail]
      Subject: file-request README

      The "file-request" service takes as an optional parameter a
      filename, and will return the contents of the file.  Text files
      are returned verbatim, while binary files are encoded via the
      Unix "uuencode" command.  Large files (greater than 1000 lines
      long) will be split into multiple mail messages.  For example,
      to get the file "README" in the /public/ada-info directory you
      would submit a message with the Subject of:

      Subject: file-request ada-info/README

      ----------------------------------------------------------------------

      Below is a sample response to a "help" request.

      From: FTP Mail Server <[e-mail]>
      Message-Id: <[e-mail]>
      To: [e-mail]
      Subject: Re: help
      In-Reply-To: <[e-mail]>
      Content-Type: text/plain; charset=us-ascii

      You have sent electronic mail to the Ada Joint Programs Office
      automatic mail server.  This server is based on the
      ServiceMail(tm) Tookit from Enterprise Integration Technologies.

      In general, you may request a service by placing its name in the
      Subject line of a mail message, followed by any needed
      parameters.  The mail server will respond to your request with
      either the information you requested or an error message.

      Here is a brief description of the available services:

      services:       This service returns a list of the available
                      services.

      Re:             This service discards all messages with "Re:" in
                      the subject line.  This is to prevent mail
                      loops.

      help:           This service returns this help message.

      info:           This service returns this help message.

      man:            This service takes as a parameter the name of a
                      service, and returns a manual page on that
                      service.

      directory:      This service takes as an optional parameter a
                      file or directory name, and returns the results
                      of an "ls -l" on that parameter.  The root of
                      the file structure is the AJPO anonymous FTP
                      area.

      file-request:   This service takes as an optional parameter a
                      file name, and will return the contents of the
                      file.  The root of the file structure is the
                      AJPO anonymous FTP area.  Text files are
                      returned verbatim, while binary files are
                      encoded via the Unix "uuencode" command.  Large
                      files (greater than 1000 lines long) will be
                      split into multiple mail messages.

      Try 'man <service>' to get more information on a particular
      service.  Please report bugs and other problems to
      [e-mail].

26) What is ASIS?

      The Ada Semantic Interface Specification is a layered
      vendor-independent open architecture.  ASIS queries and services
      provide a consistent interface to information within the Ada Program
      Library created at compile time.OK???  Clients of ASIS are shielded
      and free from the implementation details of each Ada compilerOK??
      vendor's proprietary library and intermediate representation.

      The latest working draft for ASIS is ASIS 1.1, dated March 1993.  The
      ASIS Working Group (ASISWG), under sponsorship of the AJPO, intends
      to evolve this working draft into an ISO standard complementing the
      Ada 9X standard.  The current ASIS working draft is based on Ada 83.
      Your comments are welcome, if you wish to see replies to your
      comments, please join the e-mail discussion group (discussed below)
      first.

27) How can I find out more about ASIS?  Can I take part in development?

      There is an electronic mail discussion forum for the ASISWG:
      [e-mail]

      This forum is also where announcements of ASISWG meetings will
      appear.  To have your e-mail address added to this forum, send e-mail
      to:

             [e-mail]

      Include your preferred email address, name, telephone number, and
      surface mail address.

      A separate, announcements-only, mailing list is available for those
      that do not wish to participate in the technical discussions.  That
      list is [e-mail].  To have your name added
      to the info list, send e-mail to:

             [e-mail]

28) How can I get hold of ASIS?

      ASIS 1.1 is avaiable for anonymous FTP from ajpo.sei.cmu.edu.  It is
      available, as a series of files, in the public/asis directory.

      If you have Internet FTP access, run your FTP program, your log might
      look something like this:

             $ ftp ajpo.sei.cmu.edu
             Name (ajpo.sei.cmu.edu:you): anonymous
             331 Guest login ok, send ident as password.
             Password:[e-mail]
             ftp> cd public/asis
             ftp> binary
             ftp> get asis_1.1.asc
             200 PORT command successful.
             150 Opening data connection for asis_1.1.asc (130.213.1.2,2614)
             (611652 bytes).
             ....
             ftp> bye

      (The "binary" command is not always necessary.  Some host ftp
      programs drop form-feed characters.  The binary command will prevent
      this behavior.)

      If you do not have Internet ftp access, the AJPO host provides
      mail-server capabilities.  To get more information about the
      mail-server, send e-mail to "[e-mail]", and address
      your message as:

             To: [e-mail]
             Subject: help

      To get a copy of the /public/asis/README file, address your e-mail
      as:

             To: [e-mail]
             Subject: file-request asis/README

      To get a "directory" listing of /public/asis, address your e-mail as:

             To: [e-mail]
             Subject: directory asis

      To get any of the various files, eg.  /public/asis/asis_1.1.ps,
      address your e-mail as:

             To: [e-mail]
             Subject: file-request asis/asis_1.1.ps

      The filename pattern may include the "*" wildcard.

      The files currently available are:

      asis_1.1.asc - full interface listing, line-numbered, 7-bit ASCII,
                     300 pages
      asis_1.1.ps - same as .asc file, PostScript form, 4 pages/page, 78
                     pages
      asis_1.1.index - line-number/function-name cross-index for interface,
                     7-bit ASCII
      asis_1.1.ada - full interface, in a form suitable for compilation
                     with an Ada 83 compiler
      asis_1.1.bnf - Ada 83 LRM BNF notation correlated with ASIS
                     interfaces, 7-bit ASCII
      asis_1.1.imp.ps - implementation considerations and requirements,
                     PostScript

====================================end=======================================